/*
 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package javax.swing.plaf.basic;


import sun.swing.DefaultLookup;
import sun.swing.UIAction;

import java.awt.*;
import java.awt.event.*;

import java.beans.*;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.*;

import static sun.swing.SwingUtilities2.drawHLine;
import static sun.swing.SwingUtilities2.drawRect;
import static sun.swing.SwingUtilities2.drawVLine;


/**
 * Implementation of ScrollBarUI for the Basic Look and Feel
 *
 * @author Rich Schiavi
 * @author David Kloba
 * @author Hans Muller
 */
public class BasicScrollBarUI
    extends ScrollBarUI implements LayoutManager, SwingConstants {

  private static final int POSITIVE_SCROLL = 1;
  private static final int NEGATIVE_SCROLL = -1;

  private static final int MIN_SCROLL = 2;
  private static final int MAX_SCROLL = 3;

  // NOTE: DO NOT use this field directly, SynthScrollBarUI assumes you'll
  // call getMinimumThumbSize to access it.
  protected Dimension minimumThumbSize;
  protected Dimension maximumThumbSize;

  protected Color thumbHighlightColor;
  protected Color thumbLightShadowColor;
  protected Color thumbDarkShadowColor;
  protected Color thumbColor;
  protected Color trackColor;
  protected Color trackHighlightColor;

  protected JScrollBar scrollbar;
  protected JButton incrButton;
  protected JButton decrButton;
  protected boolean isDragging;
  protected TrackListener trackListener;
  protected ArrowButtonListener buttonListener;
  protected ModelListener modelListener;

  protected Rectangle thumbRect;
  protected Rectangle trackRect;

  protected int trackHighlight;

  protected static final int NO_HIGHLIGHT = 0;
  protected static final int DECREASE_HIGHLIGHT = 1;
  protected static final int INCREASE_HIGHLIGHT = 2;

  protected ScrollListener scrollListener;
  protected PropertyChangeListener propertyChangeListener;
  protected Timer scrollTimer;

  private final static int scrollSpeedThrottle = 60; // delay in milli seconds

  /**
   * True indicates a middle click will absolutely position the
   * scrollbar.
   */
  private boolean supportsAbsolutePositioning;

  /**
   * Hint as to what width (when vertical) or height (when horizontal)
   * should be.
   *
   * @since 1.7
   */
  protected int scrollBarWidth;

  private Handler handler;

  private boolean thumbActive;

  /**
   * Determine whether scrollbar layout should use cached value or adjusted
   * value returned by scrollbar's <code>getValue</code>.
   */
  private boolean useCachedValue = false;
  /**
   * The scrollbar value is cached to save real value if the view is adjusted.
   */
  private int scrollBarValue;

  /**
   * Distance between the increment button and the track. This may be a negative
   * number. If negative, then an overlap between the button and track will occur,
   * which is useful for shaped buttons.
   *
   * @since 1.7
   */
  protected int incrGap;

  /**
   * Distance between the decrement button and the track. This may be a negative
   * number. If negative, then an overlap between the button and track will occur,
   * which is useful for shaped buttons.
   *
   * @since 1.7
   */
  protected int decrGap;

  static void loadActionMap(LazyActionMap map) {
    map.put(new Actions(Actions.POSITIVE_UNIT_INCREMENT));
    map.put(new Actions(Actions.POSITIVE_BLOCK_INCREMENT));
    map.put(new Actions(Actions.NEGATIVE_UNIT_INCREMENT));
    map.put(new Actions(Actions.NEGATIVE_BLOCK_INCREMENT));
    map.put(new Actions(Actions.MIN_SCROLL));
    map.put(new Actions(Actions.MAX_SCROLL));
  }


  public static ComponentUI createUI(JComponent c) {
    return new BasicScrollBarUI();
  }


  protected void configureScrollBarColors() {
    LookAndFeel.installColors(scrollbar, "ScrollBar.background",
        "ScrollBar.foreground");
    thumbHighlightColor = UIManager.getColor("ScrollBar.thumbHighlight");
    thumbLightShadowColor = UIManager.getColor("ScrollBar.thumbShadow");
    thumbDarkShadowColor = UIManager.getColor("ScrollBar.thumbDarkShadow");
    thumbColor = UIManager.getColor("ScrollBar.thumb");
    trackColor = UIManager.getColor("ScrollBar.track");
    trackHighlightColor = UIManager.getColor("ScrollBar.trackHighlight");
  }


  public void installUI(JComponent c) {
    scrollbar = (JScrollBar) c;
    thumbRect = new Rectangle(0, 0, 0, 0);
    trackRect = new Rectangle(0, 0, 0, 0);
    installDefaults();
    installComponents();
    installListeners();
    installKeyboardActions();
  }

  public void uninstallUI(JComponent c) {
    scrollbar = (JScrollBar) c;
    uninstallListeners();
    uninstallDefaults();
    uninstallComponents();
    uninstallKeyboardActions();
    thumbRect = null;
    scrollbar = null;
    incrButton = null;
    decrButton = null;
  }


  protected void installDefaults() {
    scrollBarWidth = UIManager.getInt("ScrollBar.width");
    if (scrollBarWidth <= 0) {
      scrollBarWidth = 16;
    }
    minimumThumbSize = (Dimension) UIManager.get("ScrollBar.minimumThumbSize");
    maximumThumbSize = (Dimension) UIManager.get("ScrollBar.maximumThumbSize");

    Boolean absB = (Boolean) UIManager.get("ScrollBar.allowsAbsolutePositioning");
    supportsAbsolutePositioning = (absB != null) ? absB.booleanValue() :
        false;

    trackHighlight = NO_HIGHLIGHT;
    if (scrollbar.getLayout() == null ||
        (scrollbar.getLayout() instanceof UIResource)) {
      scrollbar.setLayout(this);
    }
    configureScrollBarColors();
    LookAndFeel.installBorder(scrollbar, "ScrollBar.border");
    LookAndFeel.installProperty(scrollbar, "opaque", Boolean.TRUE);

    scrollBarValue = scrollbar.getValue();

    incrGap = UIManager.getInt("ScrollBar.incrementButtonGap");
    decrGap = UIManager.getInt("ScrollBar.decrementButtonGap");

    // TODO this can be removed when incrGap/decrGap become protected
    // handle scaling for sizeVarients for special case components. The
    // key "JComponent.sizeVariant" scales for large/small/mini
    // components are based on Apples LAF
    String scaleKey = (String) scrollbar.getClientProperty(
        "JComponent.sizeVariant");
    if (scaleKey != null) {
      if ("large".equals(scaleKey)) {
        scrollBarWidth *= 1.15;
        incrGap *= 1.15;
        decrGap *= 1.15;
      } else if ("small".equals(scaleKey)) {
        scrollBarWidth *= 0.857;
        incrGap *= 0.857;
        decrGap *= 0.714;
      } else if ("mini".equals(scaleKey)) {
        scrollBarWidth *= 0.714;
        incrGap *= 0.714;
        decrGap *= 0.714;
      }
    }
  }


  protected void installComponents() {
    switch (scrollbar.getOrientation()) {
      case JScrollBar.VERTICAL:
        incrButton = createIncreaseButton(SOUTH);
        decrButton = createDecreaseButton(NORTH);
        break;

      case JScrollBar.HORIZONTAL:
        if (scrollbar.getComponentOrientation().isLeftToRight()) {
          incrButton = createIncreaseButton(EAST);
          decrButton = createDecreaseButton(WEST);
        } else {
          incrButton = createIncreaseButton(WEST);
          decrButton = createDecreaseButton(EAST);
        }
        break;
    }
    scrollbar.add(incrButton);
    scrollbar.add(decrButton);
    // Force the children's enabled state to be updated.
    scrollbar.setEnabled(scrollbar.isEnabled());
  }

  protected void uninstallComponents() {
    scrollbar.remove(incrButton);
    scrollbar.remove(decrButton);
  }


  protected void installListeners() {
    trackListener = createTrackListener();
    buttonListener = createArrowButtonListener();
    modelListener = createModelListener();
    propertyChangeListener = createPropertyChangeListener();

    scrollbar.addMouseListener(trackListener);
    scrollbar.addMouseMotionListener(trackListener);
    scrollbar.getModel().addChangeListener(modelListener);
    scrollbar.addPropertyChangeListener(propertyChangeListener);
    scrollbar.addFocusListener(getHandler());

    if (incrButton != null) {
      incrButton.addMouseListener(buttonListener);
    }
    if (decrButton != null) {
      decrButton.addMouseListener(buttonListener);
    }

    scrollListener = createScrollListener();
    scrollTimer = new Timer(scrollSpeedThrottle, scrollListener);
    scrollTimer.setInitialDelay(300);  // default InitialDelay?
  }


  protected void installKeyboardActions() {
    LazyActionMap.installLazyActionMap(scrollbar, BasicScrollBarUI.class,
        "ScrollBar.actionMap");

    InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
    SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED,
        inputMap);
    inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
    SwingUtilities.replaceUIInputMap(scrollbar,
        JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap);
  }

  protected void uninstallKeyboardActions() {
    SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED,
        null);
    SwingUtilities.replaceUIActionMap(scrollbar, null);
  }

  private InputMap getInputMap(int condition) {
    if (condition == JComponent.WHEN_FOCUSED) {
      InputMap keyMap = (InputMap) DefaultLookup.get(
          scrollbar, this, "ScrollBar.focusInputMap");
      InputMap rtlKeyMap;

      if (scrollbar.getComponentOrientation().isLeftToRight() ||
          ((rtlKeyMap = (InputMap) DefaultLookup
              .get(scrollbar, this, "ScrollBar.focusInputMap.RightToLeft")) == null)) {
        return keyMap;
      } else {
        rtlKeyMap.setParent(keyMap);
        return rtlKeyMap;
      }
    } else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
      InputMap keyMap = (InputMap) DefaultLookup.get(
          scrollbar, this, "ScrollBar.ancestorInputMap");
      InputMap rtlKeyMap;

      if (scrollbar.getComponentOrientation().isLeftToRight() ||
          ((rtlKeyMap = (InputMap) DefaultLookup
              .get(scrollbar, this, "ScrollBar.ancestorInputMap.RightToLeft")) == null)) {
        return keyMap;
      } else {
        rtlKeyMap.setParent(keyMap);
        return rtlKeyMap;
      }
    }
    return null;
  }


  protected void uninstallListeners() {
    scrollTimer.stop();
    scrollTimer = null;

    if (decrButton != null) {
      decrButton.removeMouseListener(buttonListener);
    }
    if (incrButton != null) {
      incrButton.removeMouseListener(buttonListener);
    }

    scrollbar.getModel().removeChangeListener(modelListener);
    scrollbar.removeMouseListener(trackListener);
    scrollbar.removeMouseMotionListener(trackListener);
    scrollbar.removePropertyChangeListener(propertyChangeListener);
    scrollbar.removeFocusListener(getHandler());
    handler = null;
  }


  protected void uninstallDefaults() {
    LookAndFeel.uninstallBorder(scrollbar);
    if (scrollbar.getLayout() == this) {
      scrollbar.setLayout(null);
    }
  }


  private Handler getHandler() {
    if (handler == null) {
      handler = new Handler();
    }
    return handler;
  }

  protected TrackListener createTrackListener() {
    return new TrackListener();
  }

  protected ArrowButtonListener createArrowButtonListener() {
    return new ArrowButtonListener();
  }

  protected ModelListener createModelListener() {
    return new ModelListener();
  }

  protected ScrollListener createScrollListener() {
    return new ScrollListener();
  }

  protected PropertyChangeListener createPropertyChangeListener() {
    return getHandler();
  }

  private void updateThumbState(int x, int y) {
    Rectangle rect = getThumbBounds();

    setThumbRollover(rect.contains(x, y));
  }

  /**
   * Sets whether or not the mouse is currently over the thumb.
   *
   * @param active True indicates the thumb is currently active.
   * @since 1.5
   */
  protected void setThumbRollover(boolean active) {
    if (thumbActive != active) {
      thumbActive = active;
      scrollbar.repaint(getThumbBounds());
    }
  }

  /**
   * Returns true if the mouse is currently over the thumb.
   *
   * @return true if the thumb is currently active
   * @since 1.5
   */
  public boolean isThumbRollover() {
    return thumbActive;
  }

  public void paint(Graphics g, JComponent c) {
    paintTrack(g, c, getTrackBounds());
    Rectangle thumbBounds = getThumbBounds();
    if (thumbBounds.intersects(g.getClipBounds())) {
      paintThumb(g, c, thumbBounds);
    }
  }


  /**
   * A vertical scrollbar's preferred width is the maximum of
   * preferred widths of the (non <code>null</code>)
   * increment/decrement buttons,
   * and the minimum width of the thumb. The preferred height is the
   * sum of the preferred heights of the same parts.  The basis for
   * the preferred size of a horizontal scrollbar is similar.
   * <p>
   * The <code>preferredSize</code> is only computed once, subsequent
   * calls to this method just return a cached size.
   *
   * @param c the <code>JScrollBar</code> that's delegating this method to us
   * @return the preferred size of a Basic JScrollBar
   * @see #getMaximumSize
   * @see #getMinimumSize
   */
  public Dimension getPreferredSize(JComponent c) {
    return (scrollbar.getOrientation() == JScrollBar.VERTICAL)
        ? new Dimension(scrollBarWidth, 48)
        : new Dimension(48, scrollBarWidth);
  }


  /**
   * @param c The JScrollBar that's delegating this method to us.
   * @return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
   * @see #getMinimumSize
   * @see #getPreferredSize
   */
  public Dimension getMaximumSize(JComponent c) {
    return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  protected JButton createDecreaseButton(int orientation) {
    return new BasicArrowButton(orientation,
        UIManager.getColor("ScrollBar.thumb"),
        UIManager.getColor("ScrollBar.thumbShadow"),
        UIManager.getColor("ScrollBar.thumbDarkShadow"),
        UIManager.getColor("ScrollBar.thumbHighlight"));
  }

  protected JButton createIncreaseButton(int orientation) {
    return new BasicArrowButton(orientation,
        UIManager.getColor("ScrollBar.thumb"),
        UIManager.getColor("ScrollBar.thumbShadow"),
        UIManager.getColor("ScrollBar.thumbDarkShadow"),
        UIManager.getColor("ScrollBar.thumbHighlight"));
  }


  protected void paintDecreaseHighlight(Graphics g) {
    Insets insets = scrollbar.getInsets();
    Rectangle thumbR = getThumbBounds();
    g.setColor(trackHighlightColor);

    if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
      //paint the distance between the start of the track and top of the thumb
      int x = insets.left;
      int y = trackRect.y;
      int w = scrollbar.getWidth() - (insets.left + insets.right);
      int h = thumbR.y - y;
      g.fillRect(x, y, w, h);
    } else {
      //if left-to-right, fill the area between the start of the track and
      //the left edge of the thumb. If right-to-left, fill the area between
      //the end of the thumb and end of the track.
      int x, w;
      if (scrollbar.getComponentOrientation().isLeftToRight()) {
        x = trackRect.x;
        w = thumbR.x - x;
      } else {
        x = thumbR.x + thumbR.width;
        w = trackRect.x + trackRect.width - x;
      }
      int y = insets.top;
      int h = scrollbar.getHeight() - (insets.top + insets.bottom);
      g.fillRect(x, y, w, h);
    }
  }


  protected void paintIncreaseHighlight(Graphics g) {
    Insets insets = scrollbar.getInsets();
    Rectangle thumbR = getThumbBounds();
    g.setColor(trackHighlightColor);

    if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
      //fill the area between the bottom of the thumb and the end of the track.
      int x = insets.left;
      int y = thumbR.y + thumbR.height;
      int w = scrollbar.getWidth() - (insets.left + insets.right);
      int h = trackRect.y + trackRect.height - y;
      g.fillRect(x, y, w, h);
    } else {
      //if left-to-right, fill the area between the right of the thumb and the
      //end of the track. If right-to-left, then fill the area to the left of
      //the thumb and the start of the track.
      int x, w;
      if (scrollbar.getComponentOrientation().isLeftToRight()) {
        x = thumbR.x + thumbR.width;
        w = trackRect.x + trackRect.width - x;
      } else {
        x = trackRect.x;
        w = thumbR.x - x;
      }
      int y = insets.top;
      int h = scrollbar.getHeight() - (insets.top + insets.bottom);
      g.fillRect(x, y, w, h);
    }
  }


  protected void paintTrack(Graphics g, JComponent c, Rectangle trackBounds) {
    g.setColor(trackColor);
    g.fillRect(trackBounds.x, trackBounds.y, trackBounds.width, trackBounds.height);

    if (trackHighlight == DECREASE_HIGHLIGHT) {
      paintDecreaseHighlight(g);
    } else if (trackHighlight == INCREASE_HIGHLIGHT) {
      paintIncreaseHighlight(g);
    }
  }


  protected void paintThumb(Graphics g, JComponent c, Rectangle thumbBounds) {
    if (thumbBounds.isEmpty() || !scrollbar.isEnabled()) {
      return;
    }

    int w = thumbBounds.width;
    int h = thumbBounds.height;

    g.translate(thumbBounds.x, thumbBounds.y);

    g.setColor(thumbDarkShadowColor);
    drawRect(g, 0, 0, w - 1, h - 1);
    g.setColor(thumbColor);
    g.fillRect(0, 0, w - 1, h - 1);

    g.setColor(thumbHighlightColor);
    drawVLine(g, 1, 1, h - 2);
    drawHLine(g, 2, w - 3, 1);

    g.setColor(thumbLightShadowColor);
    drawHLine(g, 2, w - 2, h - 2);
    drawVLine(g, w - 2, 1, h - 3);

    g.translate(-thumbBounds.x, -thumbBounds.y);
  }


  /**
   * Returns the smallest acceptable size for the thumb.  If the scrollbar
   * becomes so small that this size isn't available, the thumb will be
   * hidden.
   * <p>
   * <b>Warning </b>: the value returned by this method should not be
   * be modified, it's a shared static constant.
   *
   * @return The smallest acceptable size for the thumb.
   * @see #getMaximumThumbSize
   */
  protected Dimension getMinimumThumbSize() {
    return minimumThumbSize;
  }

  /**
   * Returns the largest acceptable size for the thumb.  To create a fixed
   * size thumb one make this method and <code>getMinimumThumbSize</code>
   * return the same value.
   * <p>
   * <b>Warning </b>: the value returned by this method should not be
   * be modified, it's a shared static constant.
   *
   * @return The largest acceptable size for the thumb.
   * @see #getMinimumThumbSize
   */
  protected Dimension getMaximumThumbSize() {
    return maximumThumbSize;
  }


    /*
     * LayoutManager Implementation
     */

  public void addLayoutComponent(String name, Component child) {
  }

  public void removeLayoutComponent(Component child) {
  }

  public Dimension preferredLayoutSize(Container scrollbarContainer) {
    return getPreferredSize((JComponent) scrollbarContainer);
  }

  public Dimension minimumLayoutSize(Container scrollbarContainer) {
    return getMinimumSize((JComponent) scrollbarContainer);
  }

  private int getValue(JScrollBar sb) {
    return (useCachedValue) ? scrollBarValue : sb.getValue();
  }

  protected void layoutVScrollbar(JScrollBar sb) {
    Dimension sbSize = sb.getSize();
    Insets sbInsets = sb.getInsets();

        /*
         * Width and left edge of the buttons and thumb.
         */
    int itemW = sbSize.width - (sbInsets.left + sbInsets.right);
    int itemX = sbInsets.left;

        /* Nominal locations of the buttons, assuming their preferred
         * size will fit.
         */
    boolean squareButtons = DefaultLookup.getBoolean(
        scrollbar, this, "ScrollBar.squareButtons", false);
    int decrButtonH = squareButtons ? itemW :
        decrButton.getPreferredSize().height;
    int decrButtonY = sbInsets.top;

    int incrButtonH = squareButtons ? itemW :
        incrButton.getPreferredSize().height;
    int incrButtonY = sbSize.height - (sbInsets.bottom + incrButtonH);

        /* The thumb must fit within the height left over after we
         * subtract the preferredSize of the buttons and the insets
         * and the gaps
         */
    int sbInsetsH = sbInsets.top + sbInsets.bottom;
    int sbButtonsH = decrButtonH + incrButtonH;
    int gaps = decrGap + incrGap;
    float trackH = sbSize.height - (sbInsetsH + sbButtonsH) - gaps;

        /* Compute the height and origin of the thumb.   The case
         * where the thumb is at the bottom edge is handled specially
         * to avoid numerical problems in computing thumbY.  Enforce
         * the thumbs min/max dimensions.  If the thumb doesn't
         * fit in the track (trackH) we'll hide it later.
         */
    float min = sb.getMinimum();
    float extent = sb.getVisibleAmount();
    float range = sb.getMaximum() - min;
    float value = getValue(sb);

    int thumbH = (range <= 0)
        ? getMaximumThumbSize().height : (int) (trackH * (extent / range));
    thumbH = Math.max(thumbH, getMinimumThumbSize().height);
    thumbH = Math.min(thumbH, getMaximumThumbSize().height);

    int thumbY = incrButtonY - incrGap - thumbH;
    if (value < (sb.getMaximum() - sb.getVisibleAmount())) {
      float thumbRange = trackH - thumbH;
      thumbY = (int) (0.5f + (thumbRange * ((value - min) / (range - extent))));
      thumbY += decrButtonY + decrButtonH + decrGap;
    }

        /* If the buttons don't fit, allocate half of the available
         * space to each and move the lower one (incrButton) down.
         */
    int sbAvailButtonH = (sbSize.height - sbInsetsH);
    if (sbAvailButtonH < sbButtonsH) {
      incrButtonH = decrButtonH = sbAvailButtonH / 2;
      incrButtonY = sbSize.height - (sbInsets.bottom + incrButtonH);
    }
    decrButton.setBounds(itemX, decrButtonY, itemW, decrButtonH);
    incrButton.setBounds(itemX, incrButtonY, itemW, incrButtonH);

        /* Update the trackRect field.
         */
    int itrackY = decrButtonY + decrButtonH + decrGap;
    int itrackH = incrButtonY - incrGap - itrackY;
    trackRect.setBounds(itemX, itrackY, itemW, itrackH);

        /* If the thumb isn't going to fit, zero it's bounds.  Otherwise
         * make sure it fits between the buttons.  Note that setting the
         * thumbs bounds will cause a repaint.
         */
    if (thumbH >= (int) trackH) {
      if (UIManager.getBoolean("ScrollBar.alwaysShowThumb")) {
        // This is used primarily for GTK L&F, which expands the
        // thumb to fit the track when it would otherwise be hidden.
        setThumbBounds(itemX, itrackY, itemW, itrackH);
      } else {
        // Other L&F's simply hide the thumb in this case.
        setThumbBounds(0, 0, 0, 0);
      }
    } else {
      if ((thumbY + thumbH) > incrButtonY - incrGap) {
        thumbY = incrButtonY - incrGap - thumbH;
      }
      if (thumbY < (decrButtonY + decrButtonH + decrGap)) {
        thumbY = decrButtonY + decrButtonH + decrGap + 1;
      }
      setThumbBounds(itemX, thumbY, itemW, thumbH);
    }
  }


  protected void layoutHScrollbar(JScrollBar sb) {
    Dimension sbSize = sb.getSize();
    Insets sbInsets = sb.getInsets();

        /* Height and top edge of the buttons and thumb.
         */
    int itemH = sbSize.height - (sbInsets.top + sbInsets.bottom);
    int itemY = sbInsets.top;

    boolean ltr = sb.getComponentOrientation().isLeftToRight();

        /* Nominal locations of the buttons, assuming their preferred
         * size will fit.
         */
    boolean squareButtons = DefaultLookup.getBoolean(
        scrollbar, this, "ScrollBar.squareButtons", false);
    int leftButtonW = squareButtons ? itemH :
        decrButton.getPreferredSize().width;
    int rightButtonW = squareButtons ? itemH :
        incrButton.getPreferredSize().width;
    if (!ltr) {
      int temp = leftButtonW;
      leftButtonW = rightButtonW;
      rightButtonW = temp;
    }
    int leftButtonX = sbInsets.left;
    int rightButtonX = sbSize.width - (sbInsets.right + rightButtonW);
    int leftGap = ltr ? decrGap : incrGap;
    int rightGap = ltr ? incrGap : decrGap;

        /* The thumb must fit within the width left over after we
         * subtract the preferredSize of the buttons and the insets
         * and the gaps
         */
    int sbInsetsW = sbInsets.left + sbInsets.right;
    int sbButtonsW = leftButtonW + rightButtonW;
    float trackW = sbSize.width - (sbInsetsW + sbButtonsW) - (leftGap + rightGap);

        /* Compute the width and origin of the thumb.  Enforce
         * the thumbs min/max dimensions.  The case where the thumb
         * is at the right edge is handled specially to avoid numerical
         * problems in computing thumbX.  If the thumb doesn't
         * fit in the track (trackH) we'll hide it later.
         */
    float min = sb.getMinimum();
    float max = sb.getMaximum();
    float extent = sb.getVisibleAmount();
    float range = max - min;
    float value = getValue(sb);

    int thumbW = (range <= 0)
        ? getMaximumThumbSize().width : (int) (trackW * (extent / range));
    thumbW = Math.max(thumbW, getMinimumThumbSize().width);
    thumbW = Math.min(thumbW, getMaximumThumbSize().width);

    int thumbX = ltr ? rightButtonX - rightGap - thumbW : leftButtonX + leftButtonW + leftGap;
    if (value < (max - sb.getVisibleAmount())) {
      float thumbRange = trackW - thumbW;
      if (ltr) {
        thumbX = (int) (0.5f + (thumbRange * ((value - min) / (range - extent))));
      } else {
        thumbX = (int) (0.5f + (thumbRange * ((max - extent - value) / (range - extent))));
      }
      thumbX += leftButtonX + leftButtonW + leftGap;
    }

        /* If the buttons don't fit, allocate half of the available
         * space to each and move the right one over.
         */
    int sbAvailButtonW = (sbSize.width - sbInsetsW);
    if (sbAvailButtonW < sbButtonsW) {
      rightButtonW = leftButtonW = sbAvailButtonW / 2;
      rightButtonX = sbSize.width - (sbInsets.right + rightButtonW + rightGap);
    }

    (ltr ? decrButton : incrButton).setBounds(leftButtonX, itemY, leftButtonW, itemH);
    (ltr ? incrButton : decrButton).setBounds(rightButtonX, itemY, rightButtonW, itemH);

        /* Update the trackRect field.
         */
    int itrackX = leftButtonX + leftButtonW + leftGap;
    int itrackW = rightButtonX - rightGap - itrackX;
    trackRect.setBounds(itrackX, itemY, itrackW, itemH);

        /* Make sure the thumb fits between the buttons.  Note
         * that setting the thumbs bounds causes a repaint.
         */
    if (thumbW >= (int) trackW) {
      if (UIManager.getBoolean("ScrollBar.alwaysShowThumb")) {
        // This is used primarily for GTK L&F, which expands the
        // thumb to fit the track when it would otherwise be hidden.
        setThumbBounds(itrackX, itemY, itrackW, itemH);
      } else {
        // Other L&F's simply hide the thumb in this case.
        setThumbBounds(0, 0, 0, 0);
      }
    } else {
      if (thumbX + thumbW > rightButtonX - rightGap) {
        thumbX = rightButtonX - rightGap - thumbW;
      }
      if (thumbX < leftButtonX + leftButtonW + leftGap) {
        thumbX = leftButtonX + leftButtonW + leftGap + 1;
      }
      setThumbBounds(thumbX, itemY, thumbW, itemH);
    }
  }

  public void layoutContainer(Container scrollbarContainer) {
        /* If the user is dragging the value, we'll assume that the
         * scrollbars layout is OK modulo the thumb which is being
         * handled by the dragging code.
         */
    if (isDragging) {
      return;
    }

    JScrollBar scrollbar = (JScrollBar) scrollbarContainer;
    switch (scrollbar.getOrientation()) {
      case JScrollBar.VERTICAL:
        layoutVScrollbar(scrollbar);
        break;

      case JScrollBar.HORIZONTAL:
        layoutHScrollbar(scrollbar);
        break;
    }
  }


  /**
   * Set the bounds of the thumb and force a repaint that includes
   * the old thumbBounds and the new one.
   *
   * @see #getThumbBounds
   */
  protected void setThumbBounds(int x, int y, int width, int height) {
        /* If the thumbs bounds haven't changed, we're done.
         */
    if ((thumbRect.x == x) &&
        (thumbRect.y == y) &&
        (thumbRect.width == width) &&
        (thumbRect.height == height)) {
      return;
    }

        /* Update thumbRect, and repaint the union of x,y,w,h and
         * the old thumbRect.
         */
    int minX = Math.min(x, thumbRect.x);
    int minY = Math.min(y, thumbRect.y);
    int maxX = Math.max(x + width, thumbRect.x + thumbRect.width);
    int maxY = Math.max(y + height, thumbRect.y + thumbRect.height);

    thumbRect.setBounds(x, y, width, height);
    scrollbar.repaint(minX, minY, maxX - minX, maxY - minY);

    // Once there is API to determine the mouse location this will need
    // to be changed.
    setThumbRollover(false);
  }


  /**
   * Return the current size/location of the thumb.
   * <p>
   * <b>Warning </b>: the value returned by this method should not be
   * be modified, it's a reference to the actual rectangle, not a copy.
   *
   * @return The current size/location of the thumb.
   * @see #setThumbBounds
   */
  protected Rectangle getThumbBounds() {
    return thumbRect;
  }


  /**
   * Returns the current bounds of the track, i.e. the space in between
   * the increment and decrement buttons, less the insets.  The value
   * returned by this method is updated each time the scrollbar is
   * laid out (validated).
   * <p>
   * <b>Warning </b>: the value returned by this method should not be
   * be modified, it's a reference to the actual rectangle, not a copy.
   *
   * @return the current bounds of the scrollbar track
   * @see #layoutContainer
   */
  protected Rectangle getTrackBounds() {
    return trackRect;
  }

  /*
   * Method for scrolling by a block increment.
   * Added for mouse wheel scrolling support, RFE 4202656.
   */
  static void scrollByBlock(JScrollBar scrollbar, int direction) {
    // This method is called from BasicScrollPaneUI to implement wheel
    // scrolling, and also from scrollByBlock().
    int oldValue = scrollbar.getValue();
    int blockIncrement = scrollbar.getBlockIncrement(direction);
    int delta = blockIncrement * ((direction > 0) ? +1 : -1);
    int newValue = oldValue + delta;

    // Check for overflow.
    if (delta > 0 && newValue < oldValue) {
      newValue = scrollbar.getMaximum();
    } else if (delta < 0 && newValue > oldValue) {
      newValue = scrollbar.getMinimum();
    }

    scrollbar.setValue(newValue);
  }

  protected void scrollByBlock(int direction) {
    scrollByBlock(scrollbar, direction);
    trackHighlight = direction > 0 ? INCREASE_HIGHLIGHT : DECREASE_HIGHLIGHT;
    Rectangle dirtyRect = getTrackBounds();
    scrollbar.repaint(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height);
  }

  /*
   * Method for scrolling by a unit increment.
   * Added for mouse wheel scrolling support, RFE 4202656.
   *
   * If limitByBlock is set to true, the scrollbar will scroll at least 1
   * unit increment, but will not scroll farther than the block increment.
   * See BasicScrollPaneUI.Handler.mouseWheelMoved().
   */
  static void scrollByUnits(JScrollBar scrollbar, int direction,
      int units, boolean limitToBlock) {
    // This method is called from BasicScrollPaneUI to implement wheel
    // scrolling, as well as from scrollByUnit().
    int delta;
    int limit = -1;

    if (limitToBlock) {
      if (direction < 0) {
        limit = scrollbar.getValue() -
            scrollbar.getBlockIncrement(direction);
      } else {
        limit = scrollbar.getValue() +
            scrollbar.getBlockIncrement(direction);
      }
    }

    for (int i = 0; i < units; i++) {
      if (direction > 0) {
        delta = scrollbar.getUnitIncrement(direction);
      } else {
        delta = -scrollbar.getUnitIncrement(direction);
      }

      int oldValue = scrollbar.getValue();
      int newValue = oldValue + delta;

      // Check for overflow.
      if (delta > 0 && newValue < oldValue) {
        newValue = scrollbar.getMaximum();
      } else if (delta < 0 && newValue > oldValue) {
        newValue = scrollbar.getMinimum();
      }
      if (oldValue == newValue) {
        break;
      }

      if (limitToBlock && i > 0) {
        assert limit != -1;
        if ((direction < 0 && newValue < limit) ||
            (direction > 0 && newValue > limit)) {
          break;
        }
      }
      scrollbar.setValue(newValue);
    }
  }

  protected void scrollByUnit(int direction) {
    scrollByUnits(scrollbar, direction, 1, false);
  }

  /**
   * Indicates whether the user can absolutely position the thumb with
   * a mouse gesture (usually the middle mouse button).
   *
   * @return true if a mouse gesture can absolutely position the thumb
   * @since 1.5
   */
  public boolean getSupportsAbsolutePositioning() {
    return supportsAbsolutePositioning;
  }

  /**
   * A listener to listen for model changes.
   */
  protected class ModelListener implements ChangeListener {

    public void stateChanged(ChangeEvent e) {
      if (!useCachedValue) {
        scrollBarValue = scrollbar.getValue();
      }
      layoutContainer(scrollbar);
      useCachedValue = false;
    }
  }


  /**
   * Track mouse drags.
   */
  protected class TrackListener
      extends MouseAdapter implements MouseMotionListener {

    protected transient int offset;
    protected transient int currentMouseX, currentMouseY;
    private transient int direction = +1;

    public void mouseReleased(MouseEvent e) {
      if (isDragging) {
        updateThumbState(e.getX(), e.getY());
      }
      if (SwingUtilities.isRightMouseButton(e) ||
          (!getSupportsAbsolutePositioning() &&
              SwingUtilities.isMiddleMouseButton(e))) {
        return;
      }
      if (!scrollbar.isEnabled()) {
        return;
      }

      Rectangle r = getTrackBounds();
      scrollbar.repaint(r.x, r.y, r.width, r.height);

      trackHighlight = NO_HIGHLIGHT;
      isDragging = false;
      offset = 0;
      scrollTimer.stop();
      useCachedValue = true;
      scrollbar.setValueIsAdjusting(false);
    }


    /**
     * If the mouse is pressed above the "thumb" component
     * then reduce the scrollbars value by one page ("page up"),
     * otherwise increase it by one page.  If there is no
     * thumb then page up if the mouse is in the upper half
     * of the track.
     */
    public void mousePressed(MouseEvent e) {
      if (SwingUtilities.isRightMouseButton(e) ||
          (!getSupportsAbsolutePositioning() &&
              SwingUtilities.isMiddleMouseButton(e))) {
        return;
      }
      if (!scrollbar.isEnabled()) {
        return;
      }

      if (!scrollbar.hasFocus() && scrollbar.isRequestFocusEnabled()) {
        scrollbar.requestFocus();
      }

      useCachedValue = true;
      scrollbar.setValueIsAdjusting(true);

      currentMouseX = e.getX();
      currentMouseY = e.getY();

      // Clicked in the Thumb area?
      if (getThumbBounds().contains(currentMouseX, currentMouseY)) {
        switch (scrollbar.getOrientation()) {
          case JScrollBar.VERTICAL:
            offset = currentMouseY - getThumbBounds().y;
            break;
          case JScrollBar.HORIZONTAL:
            offset = currentMouseX - getThumbBounds().x;
            break;
        }
        isDragging = true;
        return;
      } else if (getSupportsAbsolutePositioning() &&
          SwingUtilities.isMiddleMouseButton(e)) {
        switch (scrollbar.getOrientation()) {
          case JScrollBar.VERTICAL:
            offset = getThumbBounds().height / 2;
            break;
          case JScrollBar.HORIZONTAL:
            offset = getThumbBounds().width / 2;
            break;
        }
        isDragging = true;
        setValueFrom(e);
        return;
      }
      isDragging = false;

      Dimension sbSize = scrollbar.getSize();
      direction = +1;

      switch (scrollbar.getOrientation()) {
        case JScrollBar.VERTICAL:
          if (getThumbBounds().isEmpty()) {
            int scrollbarCenter = sbSize.height / 2;
            direction = (currentMouseY < scrollbarCenter) ? -1 : +1;
          } else {
            int thumbY = getThumbBounds().y;
            direction = (currentMouseY < thumbY) ? -1 : +1;
          }
          break;
        case JScrollBar.HORIZONTAL:
          if (getThumbBounds().isEmpty()) {
            int scrollbarCenter = sbSize.width / 2;
            direction = (currentMouseX < scrollbarCenter) ? -1 : +1;
          } else {
            int thumbX = getThumbBounds().x;
            direction = (currentMouseX < thumbX) ? -1 : +1;
          }
          if (!scrollbar.getComponentOrientation().isLeftToRight()) {
            direction = -direction;
          }
          break;
      }
      scrollByBlock(direction);

      scrollTimer.stop();
      scrollListener.setDirection(direction);
      scrollListener.setScrollByBlock(true);
      startScrollTimerIfNecessary();
    }


    /**
     * Set the models value to the position of the thumb's top of Vertical
     * scrollbar, or the left/right of Horizontal scrollbar in
     * left-to-right/right-to-left scrollbar relative to the origin of the
     * track.
     */
    public void mouseDragged(MouseEvent e) {
      if (SwingUtilities.isRightMouseButton(e) ||
          (!getSupportsAbsolutePositioning() &&
              SwingUtilities.isMiddleMouseButton(e))) {
        return;
      }
      if (!scrollbar.isEnabled() || getThumbBounds().isEmpty()) {
        return;
      }
      if (isDragging) {
        setValueFrom(e);
      } else {
        currentMouseX = e.getX();
        currentMouseY = e.getY();
        updateThumbState(currentMouseX, currentMouseY);
        startScrollTimerIfNecessary();
      }
    }

    private void setValueFrom(MouseEvent e) {
      boolean active = isThumbRollover();
      BoundedRangeModel model = scrollbar.getModel();
      Rectangle thumbR = getThumbBounds();
      float trackLength;
      int thumbMin, thumbMax, thumbPos;

      if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
        thumbMin = trackRect.y;
        thumbMax = trackRect.y + trackRect.height - thumbR.height;
        thumbPos = Math.min(thumbMax, Math.max(thumbMin, (e.getY() - offset)));
        setThumbBounds(thumbR.x, thumbPos, thumbR.width, thumbR.height);
        trackLength = getTrackBounds().height;
      } else {
        thumbMin = trackRect.x;
        thumbMax = trackRect.x + trackRect.width - thumbR.width;
        thumbPos = Math.min(thumbMax, Math.max(thumbMin, (e.getX() - offset)));
        setThumbBounds(thumbPos, thumbR.y, thumbR.width, thumbR.height);
        trackLength = getTrackBounds().width;
      }

            /* Set the scrollbars value.  If the thumb has reached the end of
             * the scrollbar, then just set the value to its maximum.  Otherwise
             * compute the value as accurately as possible.
             */
      if (thumbPos == thumbMax) {
        if (scrollbar.getOrientation() == JScrollBar.VERTICAL ||
            scrollbar.getComponentOrientation().isLeftToRight()) {
          scrollbar.setValue(model.getMaximum() - model.getExtent());
        } else {
          scrollbar.setValue(model.getMinimum());
        }
      } else {
        float valueMax = model.getMaximum() - model.getExtent();
        float valueRange = valueMax - model.getMinimum();
        float thumbValue = thumbPos - thumbMin;
        float thumbRange = thumbMax - thumbMin;
        int value;
        if (scrollbar.getOrientation() == JScrollBar.VERTICAL ||
            scrollbar.getComponentOrientation().isLeftToRight()) {
          value = (int) (0.5 + ((thumbValue / thumbRange) * valueRange));
        } else {
          value = (int) (0.5 + (((thumbMax - thumbPos) / thumbRange) * valueRange));
        }

        useCachedValue = true;
        scrollBarValue = value + model.getMinimum();
        scrollbar.setValue(adjustValueIfNecessary(scrollBarValue));
      }
      setThumbRollover(active);
    }

    private int adjustValueIfNecessary(int value) {
      if (scrollbar.getParent() instanceof JScrollPane) {
        JScrollPane scrollpane = (JScrollPane) scrollbar.getParent();
        JViewport viewport = scrollpane.getViewport();
        Component view = viewport.getView();
        if (view instanceof JList) {
          JList list = (JList) view;
          if (DefaultLookup.getBoolean(list, list.getUI(),
              "List.lockToPositionOnScroll", false)) {
            int adjustedValue = value;
            int mode = list.getLayoutOrientation();
            int orientation = scrollbar.getOrientation();
            if (orientation == JScrollBar.VERTICAL && mode == JList.VERTICAL) {
              int index = list.locationToIndex(new Point(0, value));
              Rectangle rect = list.getCellBounds(index, index);
              if (rect != null) {
                adjustedValue = rect.y;
              }
            }
            if (orientation == JScrollBar.HORIZONTAL &&
                (mode == JList.VERTICAL_WRAP || mode == JList.HORIZONTAL_WRAP)) {
              if (scrollpane.getComponentOrientation().isLeftToRight()) {
                int index = list.locationToIndex(new Point(value, 0));
                Rectangle rect = list.getCellBounds(index, index);
                if (rect != null) {
                  adjustedValue = rect.x;
                }
              } else {
                Point loc = new Point(value, 0);
                int extent = viewport.getExtentSize().width;
                loc.x += extent - 1;
                int index = list.locationToIndex(loc);
                Rectangle rect = list.getCellBounds(index, index);
                if (rect != null) {
                  adjustedValue = rect.x + rect.width - extent;
                }
              }
            }
            value = adjustedValue;

          }
        }
      }
      return value;
    }

    private void startScrollTimerIfNecessary() {
      if (scrollTimer.isRunning()) {
        return;
      }

      Rectangle tb = getThumbBounds();

      switch (scrollbar.getOrientation()) {
        case JScrollBar.VERTICAL:
          if (direction > 0) {
            if (tb.y + tb.height < trackListener.currentMouseY) {
              scrollTimer.start();
            }
          } else if (tb.y > trackListener.currentMouseY) {
            scrollTimer.start();
          }
          break;
        case JScrollBar.HORIZONTAL:
          if ((direction > 0 && isMouseAfterThumb())
              || (direction < 0 && isMouseBeforeThumb())) {

            scrollTimer.start();
          }
          break;
      }
    }

    public void mouseMoved(MouseEvent e) {
      if (!isDragging) {
        updateThumbState(e.getX(), e.getY());
      }
    }

    /**
     * Invoked when the mouse exits the scrollbar.
     *
     * @param e MouseEvent further describing the event
     * @since 1.5
     */
    public void mouseExited(MouseEvent e) {
      if (!isDragging) {
        setThumbRollover(false);
      }
    }
  }


  /**
   * Listener for cursor keys.
   */
  protected class ArrowButtonListener extends MouseAdapter {

    // Because we are handling both mousePressed and Actions
    // we need to make sure we don't fire under both conditions.
    // (keyfocus on scrollbars causes action without mousePress
    boolean handledEvent;

    public void mousePressed(MouseEvent e) {
      if (!scrollbar.isEnabled()) {
        return;
      }
      // not an unmodified left mouse button
      //if(e.getModifiers() != InputEvent.BUTTON1_MASK) {return; }
      if (!SwingUtilities.isLeftMouseButton(e)) {
        return;
      }

      int direction = (e.getSource() == incrButton) ? 1 : -1;

      scrollByUnit(direction);
      scrollTimer.stop();
      scrollListener.setDirection(direction);
      scrollListener.setScrollByBlock(false);
      scrollTimer.start();

      handledEvent = true;
      if (!scrollbar.hasFocus() && scrollbar.isRequestFocusEnabled()) {
        scrollbar.requestFocus();
      }
    }

    public void mouseReleased(MouseEvent e) {
      scrollTimer.stop();
      handledEvent = false;
      scrollbar.setValueIsAdjusting(false);
    }
  }


  /**
   * Listener for scrolling events initiated in the
   * <code>ScrollPane</code>.
   */
  protected class ScrollListener implements ActionListener {

    int direction = +1;
    boolean useBlockIncrement;

    public ScrollListener() {
      direction = +1;
      useBlockIncrement = false;
    }

    public ScrollListener(int dir, boolean block) {
      direction = dir;
      useBlockIncrement = block;
    }

    public void setDirection(int direction) {
      this.direction = direction;
    }

    public void setScrollByBlock(boolean block) {
      this.useBlockIncrement = block;
    }

    public void actionPerformed(ActionEvent e) {
      if (useBlockIncrement) {
        scrollByBlock(direction);
        // Stop scrolling if the thumb catches up with the mouse
        if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {
          if (direction > 0) {
            if (getThumbBounds().y + getThumbBounds().height
                >= trackListener.currentMouseY) {
              ((Timer) e.getSource()).stop();
            }
          } else if (getThumbBounds().y <= trackListener.currentMouseY) {
            ((Timer) e.getSource()).stop();
          }
        } else {
          if ((direction > 0 && !isMouseAfterThumb())
              || (direction < 0 && !isMouseBeforeThumb())) {

            ((Timer) e.getSource()).stop();
          }
        }
      } else {
        scrollByUnit(direction);
      }

      if (direction > 0
          && scrollbar.getValue() + scrollbar.getVisibleAmount()
          >= scrollbar.getMaximum()) {
        ((Timer) e.getSource()).stop();
      } else if (direction < 0
          && scrollbar.getValue() <= scrollbar.getMinimum()) {
        ((Timer) e.getSource()).stop();
      }
    }
  }

  private boolean isMouseLeftOfThumb() {
    return trackListener.currentMouseX < getThumbBounds().x;
  }

  private boolean isMouseRightOfThumb() {
    Rectangle tb = getThumbBounds();
    return trackListener.currentMouseX > tb.x + tb.width;
  }

  private boolean isMouseBeforeThumb() {
    return scrollbar.getComponentOrientation().isLeftToRight()
        ? isMouseLeftOfThumb()
        : isMouseRightOfThumb();
  }

  private boolean isMouseAfterThumb() {
    return scrollbar.getComponentOrientation().isLeftToRight()
        ? isMouseRightOfThumb()
        : isMouseLeftOfThumb();
  }

  private void updateButtonDirections() {
    int orient = scrollbar.getOrientation();
    if (scrollbar.getComponentOrientation().isLeftToRight()) {
      if (incrButton instanceof BasicArrowButton) {
        ((BasicArrowButton) incrButton).setDirection(
            orient == HORIZONTAL ? EAST : SOUTH);
      }
      if (decrButton instanceof BasicArrowButton) {
        ((BasicArrowButton) decrButton).setDirection(
            orient == HORIZONTAL ? WEST : NORTH);
      }
    } else {
      if (incrButton instanceof BasicArrowButton) {
        ((BasicArrowButton) incrButton).setDirection(
            orient == HORIZONTAL ? WEST : SOUTH);
      }
      if (decrButton instanceof BasicArrowButton) {
        ((BasicArrowButton) decrButton).setDirection(
            orient == HORIZONTAL ? EAST : NORTH);
      }
    }
  }

  public class PropertyChangeHandler implements PropertyChangeListener {
    // NOTE: This class exists only for backward compatibility. All
    // its functionality has been moved into Handler. If you need to add
    // new functionality add it to the Handler, but make sure this
    // class calls into the Handler.

    public void propertyChange(PropertyChangeEvent e) {
      getHandler().propertyChange(e);
    }
  }


  /**
   * Used for scrolling the scrollbar.
   */
  private static class Actions extends UIAction {

    private static final String POSITIVE_UNIT_INCREMENT =
        "positiveUnitIncrement";
    private static final String POSITIVE_BLOCK_INCREMENT =
        "positiveBlockIncrement";
    private static final String NEGATIVE_UNIT_INCREMENT =
        "negativeUnitIncrement";
    private static final String NEGATIVE_BLOCK_INCREMENT =
        "negativeBlockIncrement";
    private static final String MIN_SCROLL = "minScroll";
    private static final String MAX_SCROLL = "maxScroll";

    Actions(String name) {
      super(name);
    }

    public void actionPerformed(ActionEvent e) {
      JScrollBar scrollBar = (JScrollBar) e.getSource();
      String key = getName();
      if (key == POSITIVE_UNIT_INCREMENT) {
        scroll(scrollBar, POSITIVE_SCROLL, false);
      } else if (key == POSITIVE_BLOCK_INCREMENT) {
        scroll(scrollBar, POSITIVE_SCROLL, true);
      } else if (key == NEGATIVE_UNIT_INCREMENT) {
        scroll(scrollBar, NEGATIVE_SCROLL, false);
      } else if (key == NEGATIVE_BLOCK_INCREMENT) {
        scroll(scrollBar, NEGATIVE_SCROLL, true);
      } else if (key == MIN_SCROLL) {
        scroll(scrollBar, BasicScrollBarUI.MIN_SCROLL, true);
      } else if (key == MAX_SCROLL) {
        scroll(scrollBar, BasicScrollBarUI.MAX_SCROLL, true);
      }
    }

    private void scroll(JScrollBar scrollBar, int dir, boolean block) {

      if (dir == NEGATIVE_SCROLL || dir == POSITIVE_SCROLL) {
        int amount;
        // Don't use the BasicScrollBarUI.scrollByXXX methods as we
        // don't want to use an invokeLater to reset the trackHighlight
        // via an invokeLater
        if (block) {
          if (dir == NEGATIVE_SCROLL) {
            amount = -1 * scrollBar.getBlockIncrement(-1);
          } else {
            amount = scrollBar.getBlockIncrement(1);
          }
        } else {
          if (dir == NEGATIVE_SCROLL) {
            amount = -1 * scrollBar.getUnitIncrement(-1);
          } else {
            amount = scrollBar.getUnitIncrement(1);
          }
        }
        scrollBar.setValue(scrollBar.getValue() + amount);
      } else if (dir == BasicScrollBarUI.MIN_SCROLL) {
        scrollBar.setValue(scrollBar.getMinimum());
      } else if (dir == BasicScrollBarUI.MAX_SCROLL) {
        scrollBar.setValue(scrollBar.getMaximum());
      }
    }
  }


  //
  // EventHandler
  //
  private class Handler implements FocusListener, PropertyChangeListener {

    //
    // FocusListener
    //
    public void focusGained(FocusEvent e) {
      scrollbar.repaint();
    }

    public void focusLost(FocusEvent e) {
      scrollbar.repaint();
    }


    //
    // PropertyChangeListener
    //
    public void propertyChange(PropertyChangeEvent e) {
      String propertyName = e.getPropertyName();

      if ("model" == propertyName) {
        BoundedRangeModel oldModel = (BoundedRangeModel) e.getOldValue();
        BoundedRangeModel newModel = (BoundedRangeModel) e.getNewValue();
        oldModel.removeChangeListener(modelListener);
        newModel.addChangeListener(modelListener);
        scrollBarValue = scrollbar.getValue();
        scrollbar.repaint();
        scrollbar.revalidate();
      } else if ("orientation" == propertyName) {
        updateButtonDirections();
      } else if ("componentOrientation" == propertyName) {
        updateButtonDirections();
        InputMap inputMap = getInputMap(JComponent.WHEN_FOCUSED);
        SwingUtilities.replaceUIInputMap(scrollbar, JComponent.WHEN_FOCUSED, inputMap);
      }
    }
  }
}
